public class prog {

}






/**这是个智力题
 * 1.首先他已经给了你这个中间节点。
 * 2.直接对这个节点进行操作即可。
 * 3.将此节点赋值为下一个节点的值。
 * 4.将此节点的指针域存储此节点+2的节点地址。
 * 5.这样就将此节点替换为下一个节点，此节点消失。
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
//class Solution {
//    public void deleteNode(ListNode node) {
//        node.val=node.next.val;
//        node.next=node.next.next;
//    }
//}








/**返回倒数第 k 个节点
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
//class Solution {
//    public int kthToLast(ListNode head, int k) {
//        ListNode fast=head;
//        ListNode slow=head;
//        while(k>0){
//            fast=fast.next;
//            k--;
//        }
//        while(fast!=null){
//            fast=fast.next;
//            slow=slow.next;
//        }
//        return slow.val;
//    }
//}










/**无序链表，删除重复节点，暴力方法，设置一个点，每一个进行比较。
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
//class Solution {
//    public ListNode removeDuplicateNodes(ListNode head) {
//        ListNode cur=head;
//        while(cur!=null){
//            ListNode newcur=cur;
//            while(newcur.next!=null){
//                if(cur.val==newcur.next.val){
//                    newcur.next=newcur.next.next;
//                }
//                else{
//                    newcur=newcur.next;
//                }
//            }
//            cur=cur.next;
//        }
//        return head;
//    }
//}








/**回文链表
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
//class Solution {
//    public boolean isPalindrome(ListNode head) {
//        if(head==null){
//            return false;
//        }
//        ListNode fast=head;
//        ListNode slow=head;
//        while(fast!=null&&fast.next!=null){
//            fast=fast.next.next;
//            slow=slow.next;
//        }
//        fast=slow;
//        ListNode perv=null;
//        while(fast!=null){
//            ListNode fastnext=fast.next;
//            fast.next=perv;
//            perv=fast;
//            fast=fastnext;
//        }
//        slow=head;
//        fast=perv;
//        while(fast!=null){
//            if(slow.val!=fast.val){
//                return false;
//            }
//            fast=fast.next;
//            slow=slow.next;
//        }
//        return true;
//    }
//}










/**反转链表
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
//class Solution {
//    public ListNode reverseList(ListNode head) {
//        ListNode perv=null;
//        ListNode cur=head;
//        while(cur!=null){
//            ListNode curnext=cur.next;
//            cur.next=perv;
//            perv=cur;
//            cur=curnext;
//        }
//        return perv;
//    }
//}











/** 两个链表的第一个公共节点
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
//public class Solution {
//    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
//        if(headB==null||headA==null){
//            return null;
//        }
//        ListNode cura=headA;
//        ListNode curb=headB;
//        int lena=0;
//        int lenb=0;
//        int len=0;
//        while(cura!=null){
//            cura=cura.next;
//            lena++;
//        }
//        while(curb!=null){
//            lenb++;
//            curb=curb.next;
//        }
//        len=lena-lenb;
//        if(len<0){
//            len=lenb-lena;
//            cura=headB;
//            curb=headA;
//        }
//        else{
//            cura=headA;
//            curb=headB;
//        }
//        while(len>0){
//            cura=cura.next;
//            len--;
//        }
//        while(cura!=null&&curb!=null){
//            if(cura==curb){
//                return cura;
//            }
//            cura=cura.next;
//            curb=curb.next;
//        }
//        return null;
//
//    }
//}










/**合并两个排序的链表
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
//class Solution {
//    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
//        if(l1==null&&l2==null){
//            return null;
//        }
//        if(l1==null){
//            return l2;
//        }
//        else if(l2==null){
//            return l1;
//        }
//        ListNode head=new ListNode(-1);
//        ListNode cur=head;
//        while(l1!=null&&l2!=null){
//            if(l1.val>l2.val){
//                cur.next=l2;
//                l2=l2.next;
//            }
//            else {
//                cur.next=l1;
//                l1=l1.next;
//            }
//            cur=cur.next;
//        }
//        if(l1==null&&l2!=null){
//            cur.next=l2;
//        }
//        else if(l2==null&&l1!=null){
//            cur.next=l1;
//        }
//        return head.next;
//    }
//}








//旋转数组
//class Solution {
//    public void rotate(int[] nums, int k) {
//        int len=k%nums.length;
//        reveres(nums,0,nums.length-1);
//        reveres(nums,0,len-1);
//        reveres(nums,len,nums.length-1);
//    }
//    public void reveres(int[] nums,int l,int r){
//        while(l<r){
//            int tmp=nums[l];
//            nums[l]=nums[r];
//            nums[r]=tmp;
//            l++;
//            r--;
//        }
//    }
//}











//有序数组的平方
//class Solution {
//    public int[] sortedSquares(int[] nums) {
//        int[] arr=new int[nums.length];
//        for(int i=0;i<nums.length;i++){
//            arr[i]=nums[i]*nums[i];
//        }
//        Arrays.sort(arr);
//        return arr;
//    }
//}
